# services/user.py
"""
Author: didiplus
Description: 用户服务类
Date: 2025-08-20 20:54:00
LastEditors: didiplus
LastEditTime: 2025-08-20 20:54:00
FilePath: /WeChatBot/app/services/user.py
Version: 1.0
"""



from sqlalchemy.orm import Session
from sqlalchemy.exc import IntegrityError
from typing import Optional, List
import bcrypt
from datetime import datetime

from models.user import User
from schemas.user import UserCreate, UserUpdate

class UserService:
    """
    用户服务类
    提供用户相关的业务逻辑处理
    """
    
    def __init__(self, db: Session):
        """
        初始化用户服务
        
        Args:
            db (Session): 数据库会话对象
        """
        self.db = db
    
    def create_user(self, user_create: UserCreate) -> User:
        """
        创建新用户
        
        Args:
            user_create (UserCreate): 用户创建数据
            
        Returns:
            User: 创建的用户对象
            
        Raises:
            ValueError: 用户名或邮箱已存在
        """
        # 检查用户名是否已存在
        if self.get_user_by_username(user_create.username):
            raise ValueError("用户名已存在")
        
        # 检查邮箱是否已存在（如果提供了邮箱）
        if user_create.email and self.get_user_by_email(user_create.email):
            raise ValueError("邮箱已存在")
        
        # 创建用户对象
        db_user = User(
            username=user_create.username,
            email=user_create.email,
            nickname=user_create.nickname
        )
        
        # 设置密码哈希
        db_user.set_password(user_create.password)
        
        # 保存到数据库
        self.db.add(db_user)
        try:
            self.db.commit()
            self.db.refresh(db_user)
            return db_user
        except IntegrityError:
            self.db.rollback()
            raise ValueError("用户创建失败")
    
    def get_user_by_id(self, user_id: int) -> Optional[User]:
        """
        根据ID获取用户
        
        Args:
            user_id (int): 用户ID
            
        Returns:
            Optional[User]: 用户对象，如果不存在返回None
        """
        return self.db.query(User).filter(User.id == user_id, User.is_active == True).first()
    
    def get_user_by_username(self, username: str) -> Optional[User]:
        """
        根据用户名获取用户
        
        Args:
            username (str): 用户名
            
        Returns:
            Optional[User]: 用户对象，如果不存在返回None
        """
        return self.db.query(User).filter(User.username == username, User.is_active == True).first()
    
    def get_user_by_email(self, email: str) -> Optional[User]:
        """
        根据邮箱获取用户
        
        Args:
            email (str): 邮箱地址
            
        Returns:
            Optional[User]: 用户对象，如果不存在返回None
        """
        return self.db.query(User).filter(User.email == email, User.is_active == True).first()
    
    def get_users(self, skip: int = 0, limit: int = 100) -> List[User]:
        """
        获取用户列表
        
        Args:
            skip (int): 跳过的记录数
            limit (int): 返回的记录数
            
        Returns:
            List[User]: 用户列表
        """
        return self.db.query(User).filter(User.is_active == True).offset(skip).limit(limit).all()
    
    def update_user(self, user_id: int, user_update: UserUpdate) -> Optional[User]:
        """
        更新用户信息
        
        Args:
            user_id (int): 用户ID
            user_update (UserUpdate): 用户更新数据
            
        Returns:
            Optional[User]: 更新后的用户对象，如果用户不存在返回None
            
        Raises:
            ValueError: 邮箱已存在
        """
        db_user = self.get_user_by_id(user_id)
        if not db_user:
            return None
        
        # 更新用户信息
        update_data = user_update.dict(exclude_unset=True)
        for field, value in update_data.items():
            if value is not None:
                setattr(db_user, field, value)
        
        # 如果更新了邮箱，检查是否已存在
        if user_update.email and user_update.email != db_user.email:
            if self.get_user_by_email(user_update.email):
                raise ValueError("邮箱已存在")
        
        db_user.updated_at = datetime.now()
        self.db.commit()
        self.db.refresh(db_user)
        return db_user
    
    def delete_user(self, user_id: int) -> bool:
        """
        删除用户（软删除）
        
        Args:
            user_id (int): 用户ID
            
        Returns:
            bool: 删除成功返回True，用户不存在返回False
        """
        db_user = self.get_user_by_id(user_id)
        if not db_user:
            return False
        
        db_user.is_active = False
        db_user.updated_at = datetime.now()
        self.db.commit()
        return True
    
    def authenticate_user(self, username: str, password: str) -> Optional[User]:
        """
        验证用户身份
        
        Args:
            username (str): 用户名
            password (str): 密码
            
        Returns:
            Optional[User]: 验证成功的用户对象，验证失败返回None
        """
       
        user = self.get_user_by_username(username)
        if not user:
            return None
        
        if user.verify_password(password):
            return user
        
        return None